package com.spring.boot.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.spring.boot.dao.InsuredMapper;
import com.spring.boot.dao.UserMapper;
import com.spring.boot.entity.Insured;
import com.spring.boot.service.InsuredService;
import com.spring.boot.utils.ServiceException;
import com.spring.boot.vo.QueryRequest;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author: Daniel ZTQ
 * @Date: 2021/01/01 22:59
 * @Description: 被保险人信息业务逻辑层 接口实现
 */
@Slf4j
@Service
public class InsuredServiceImpl extends ServiceImpl<InsuredMapper, Insured> implements InsuredService {

    @Autowired
    private InsuredMapper insuredMapper;

    @Autowired
    private UserMapper userMapper;


    /**
     * 新增被保险人实现接口（普通用户）
     */
    @Override
    public Map<String, Object> addInsured(Insured insured) {
        //定义map对象
        Map<String, Object> result = new HashMap<>();
        try {
            //获取用户id
            String uid = insured.getUid();
            //获取被保险人身份证号
            String identityCard = insured.getIdentityCard();
            //获取被保险人姓名
            String name = insured.getName();
            //获取被保险人手机号
            String mobile = insured.getMobile();
            //获取被保险人地址
            String address = insured.getAddress();
            //获取被保险人性别
            Integer sex = insured.getSex();
            //如果用户id为空
            if (uid == null || uid.equals("")){
                //日志打印
                log.info("用户id不能为空！");
                //设置状态码
                result.put("code", 300);
                //设置msg值
                result.put("msg", "用户id不能为空！");
                //设置status值
                result.put("status", false);
                //返回result
                return result;
            }
            //如果被保险人身份证号为空
            if (identityCard == null || identityCard.equals("")){
                //日志打印
                log.info("被保险人身份证号不能为空！");
                //设置状态码
                result.put("code", 300);
                //设置msg值
                result.put("msg", "被保险人身份证号不能为空！");
                //设置status值
                result.put("status", false);
                //返回result
                return result;
            }
            //如果被保险人性别为空
            if (sex == null ){
                //日志打印
                log.info("被保险人性别不能为空！");
                //设置状态码
                result.put("code", 300);
                //设置msg值
                result.put("msg", "被保险人性别不能为空！");
                //设置status值
                result.put("status", false);
                //返回result
                return result;
            }
            //如果被保险人姓名为空
            if (name == null || name.equals("")){
                //日志打印
                log.info("被保险人姓名不能为空！");
                //设置状态码
                result.put("code", 300);
                //设置msg值
                result.put("msg", "被保险人姓名不能为空！");
                //设置status值
                result.put("status", false);
                //返回result
                return result;
            }
            //如果被保险人手机号为空
            if (mobile == null || mobile.equals("")){
                //日志打印
                log.info("被保险人手机号不能为空！");
                //设置状态码
                result.put("code", 300);
                //设置msg值
                result.put("msg", "被保险人手机号不能为空！");
                //设置status值
                result.put("status", false);
                //返回result
                return result;
            }
            //如果被保险人地址为空
            if (address == null || address.equals("")){
                //日志打印
                log.info("被保险人地址不能为空！");
                //设置状态码
                result.put("code", 300);
                //设置msg值
                result.put("msg", "被保险人地址不能为空！");
                //设置status值
                result.put("status", false);
                //返回result
                return result;
            }
            //根据用户id和身份证号查询该被保险人是否存在
            List<Insured> insuredByUidAndidentityCard = insuredMapper.getInsuredByUidAndidentityCard(uid, identityCard);
            //如果存在，则说明该用户下有该被保险人信息
            if (insuredByUidAndidentityCard.size() > 0) {
                //日志打印
                log.error("该被保险人信息已经存在");
                //设置状态码
                result.put("code", 300);
                //设置msg值
                result.put("msg", "该被保险人信息已经存在！");
                //设置status值
                result.put("status", false);
            } else {
                //否则，说明该用户没有该被保险人，则可进行添加
                //调用insuredMapper层的insert的sql进行保存被保险人信息
                insuredMapper.insert(insured);
                //日志打印
                log.error("新增被保险人成功！");
                //设置状态码
                result.put("code", 200);
                //设置msg值
                result.put("msg", "新增被保险人成功！");
                //设置status值
                result.put("status", true);
            }
        } catch (Exception e) {
            //日志打印"添加被保险人调用接口失败"
            log.error("添加被保险人调用接口失败", e);
            //设置状态码
            result.put("code", 500);
            //设置msg值
            result.put("msg", "添加被保险人调用接口失败！");
            //设置status值
            result.put("status", false);
            //抛出异常
            throw new ServiceException("添加被保险人失败");
        }
        return result;
    }


    /**
     * 删除被保险人实现接口（普通用户）
     */
    @Override
    public Map<String, Object> deleteBatchIdsInsured(String id) {
        //定义map对象
        Map<String, Object> result = new HashMap<>();
        try {
            //以逗号分隔
            String[] split = id.split(",");
            //创建list集合
            List<String> idList = new ArrayList<>();
            //for循环遍历，以逗号分隔 要删除的被保险人
            for (String str : split) {
                //将要删除的被保险人信息 放入list集合里面
                idList.add(str);
            }
            //调用insuredMapper层的deleteBatchIds的sql，批量删除被保险人
            insuredMapper.deleteBatchIds(idList);
            //日志打印
            log.error("删除被保险人信息成功！");
            //设置状态码
            result.put("code", 200);
            //设置msg值
            result.put("msg", "删除被保险人信息成功！");
            //设置status值
            result.put("status", true);
        } catch (Exception e) {
            //日志打印“被保险人信息删除失败”
            log.error("被保险人信息删除失败", e);
            //设置状态码
            result.put("code", 500);
            //设置msg值
            result.put("msg", "删除被保险人信息失败！");
            //设置status值
            result.put("status", false);
            //抛出异常
            throw new ServiceException("被保险人信息删除失败");
        }
        //返回结果
        return result;
    }


    /**
     * 修改被保险人信息实现接口（管理员/普通用户）
     */
    @Override
    public Map<String, Object> updateInsured(Insured insured) {
        //定义map对象
        Map<String, Object> result = new HashMap<>();
        try {
            //调用insuredMapper层的updateById的sql修改被保险人信息
            insuredMapper.updateById(insured);
            //日志打印
            log.error("修改成功！");
            //设置状态码
            result.put("code", 200);
            //设置msg值
            result.put("msg", "修改成功！");
            //设置status值
            result.put("status", true);
        } catch (Exception e) {
            //日志打印“被保险人信息修改失败”
            log.error("调用被保险人修改信息接口失败", e);
            //设置状态码
            result.put("code", 500);
            //设置msg值
            result.put("msg", "调用被保险人修改信息接口失败！");
            //设置status值
            result.put("status", false);
            //抛出异常
            throw new ServiceException("调用被保险人修改信息接口失败");
        }
        //返回结果
        return result;
    }

    /**
     * 被保险人筛选查询功能（普通用户/管理员）  （注：普通用户仅查看自己添加的被保险人，管理员科查看所有被保险人信息）
     */
    @Override
    public Map<String, Object> findInsuredList(QueryRequest queryRequest, Insured insured) {
        //定义map对象
        Map<String, Object> result = new HashMap<>();
        try {
            //创建一个insured对象
            LambdaQueryWrapper<Insured> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            //如果获取到的当前用户id不为空
            if (StringUtils.isNotEmpty(insured.getUid())) {
                //根据当前登录用户的uid，获取当前登录用户角色
                String role = userMapper.getUserByUid(insured.getUid()).getRole();
                //如果为管理员
                if ("0".equals(role)) {

                } else {
                    //如果为普通用户
                    //则根据用户id进行查询（非模糊查询）
                    lambdaQueryWrapper.eq(Insured::getUid, insured.getUid());
                }
            }
            //如果获取到的用户姓名不为空
            if (StringUtils.isNotEmpty(insured.getName())) {
                //则根据姓名进行模糊查询
                lambdaQueryWrapper.like(Insured::getName, insured.getName());
            }
            //如果获取到的用户身份证号不为空
            if (StringUtils.isNotEmpty(insured.getIdentityCard())) {
                //则根据身份证号进行查询（非模糊查询）
                lambdaQueryWrapper.eq(Insured::getIdentityCard, insured.getIdentityCard());
            }
            //如果获取到的手机号不为空
            if (StringUtils.isNotEmpty(insured.getMobile())) {
                //则根据手机号进行查询（非模糊查询）
                lambdaQueryWrapper.eq(Insured::getMobile, insured.getMobile());
            }

            //根据被保险id进行正序排序
            lambdaQueryWrapper.orderByAsc(Insured::getId);
            //创建分页对象
            Page<Insured> page = new Page<>(queryRequest.getPageNum(), queryRequest.getPageSize());
            //进行分页处理
            IPage<Insured> page1 = this.page(page, lambdaQueryWrapper);
            //日志打印
            log.error("筛选查询被保险人信息成功");
            //设置状态码
            result.put("code", 200);
            //设置data值
            result.put("data",page1);
            //设置msg值
            result.put("msg", "查询被保险人信息成功！");
            //设置status值
            result.put("status", true);
        } catch (Exception e) {
            //打印日志
            log.error("筛选查询被保险人信息失败:", e);
            //设置状态码
            result.put("code", 500);
            //设置msg值
            result.put("msg", "调用筛选查询被保险人信息接口失败！");
            //设置status值
            result.put("status", false);
            throw new ServiceException("调用筛选查询被保险人信息接口失败！");
        }
        //返回结果
        return result;
    }

    /**
     *  根据uid查询被保险人信息
     * */
    @Override
    public Map<String, Object> findInsuredListByUid(String uid) {
        //定义map对象
        Map<String, Object> result = new HashMap<>();
        try{
            //根据被保险人id，获取被保险人信息
            List<Insured> insuredByUid = insuredMapper.getInsuredByUid(uid);
            //日志打印
            log.error("根据uid查询被保险人信息成功");
            //设置状态码
            result.put("code", 200);
            //设置data值
            result.put("data",insuredByUid);
            //设置msg值
            result.put("msg", "查询被保险人信息成功！");
            //设置status值
            result.put("status", true);
        }catch (Exception e){
            //打印日志
            log.error("根据uid查询被保险人信息失败:", e);
            //设置状态码
            result.put("code", 500);
            //设置msg值
            result.put("msg", "根据uid查询被保险人信息失败！");
            //设置status值
            result.put("status", false);
            throw new ServiceException("根据uid查询被保险人信息失败！");
        }
        return result;
    }

    /**
     * 根据id查询被保险人信息
     * */
    @Override
    public Map<String, Object> findInsuredById(String id) {
        //定义map对象
        Map<String, Object> result = new HashMap<>();
        try{
            Insured insured = insuredMapper.selectById(id);
            //日志打印
            log.error("根据id查询被保险人信息成功");
            //设置状态码
            result.put("code", 200);
            //设置data值
            result.put("data",insured);
            //设置msg值
            result.put("msg", "根据id查询被保险人信息成功！");
            //设置status值
            result.put("status", true);
        }catch (Exception e){
            //打印日志
            log.error("根据id查询被保险人信息失败:", e);
            //设置状态码
            result.put("code", 500);
            //设置msg值
            result.put("msg", "根据id查询被保险人信息失败！");
            //设置status值
            result.put("status", false);
            //抛出异常
            throw new ServiceException("根据id查询被保险人信息失败！");
        }
        return result;
    }

}
